package com.yaoxiaoqing.basis;

import java.util.Random;
import java.util.Scanner;

public class MultiArray {
    public static void main(String[] args) {
        /*
         * 二维数组的使用
         *
         * 1.理解
         * 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
         * 其实，从数组底层的运行机制来看，其实没有多维数组。
         *
         * 2.二维数组的使用：
         * 	① 二维数组的初始化
         *  ② 如何调用数组的指定位置的元素
         *  ③ 如何获取数组的长度
         *  ④ 如何遍历数组
         *  ⑤ 数组元素的默认初始化值:见ArrayTest3.java
         *  ⑥ 数组的内存解析:见ArrayTest3.java
         * https://blog.csdn.net/PorkBird/article/details/113694291
         */
        //1.二维数组初始化和声明
        int[] arrB = new int[]{1, 2, 3};
        //静态初始化
        int[][] arrB1 = new int[][]{{1, 2,3}, {4, 5, 6}, {7, 8, 9}};
        //动态初始化1
        int[][] arrB2 = new int[3][2];
        //动态初始化2
        String[][] arrB3 = new String[3][];

        //错误的情况
//        String[][] arrB4=new String[][];
//        String[][] arrB5=new String[][3];//必须动态声明数组长度
//        String[][] arrB6 = new String[4][3] {{"1","2","3"},{"1","2","3"},{"1","2","3"},{"1","2","3"}};//已经赋值静态声明了就不用写[4][3]个数了

        int arrB4[][] = new int[][]{ {1,2,3,},{1,2,3},{1,2,3} };
        int[] arrB5[]=new int[3][];
        int[][] arrB6 = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}};

        //2.调用数组指定位置的元素
        System.out.println(arrB1[0][2]);//3

        arrB3[1]=new String[4];//定义arr3的[1]为长度为4的字符数组
        System.out.println(arrB3[1][0]);// null 没有上句，会报错

//        3.获取数组长度

        System.out.println(arrB4.length);//3
        System.out.println(arrB4[0].length);//3
        System.out.println(arrB4[1].length);//3

        //4.遍历二维数组
        for (int i = 0; i < arrB4.length; i++) {
            for (int j = 0; j < arrB4[i].length; j++) {
                System.out.println(arrB4[i][j] + " ");
            }
            System.out.println();
        }


        /*
         * 二维数组的使用：
         * 	规定：二维数组分为外层数组的元素，内层数组的元素
         * 	int[][] arr = new int[4][3];
         *  外层元素:arr[0],arr[1]等
         *  内层元素:arr[0][0],arr[1][2]等
         *
         * 	⑤ 数组元素的默认初始化值
         * 	针对于初始化方式一：比如：int[][] arr = new int[4][3];
         * 		外层元素的初始化值为：地址值
         * 		内层元素的初始化值为：与一维数组初始化情况相同
         *
         * 针对于初始化方式而：比如：int[][] arr = new int[4][];
         * 		外层元素的初始化值为：null
         * 		内层元素的初始化值为：不能调用，否则报错。
         *
         * 	⑥ 数组的内存解析
         */

        int[][] arr = new int[3][4];//[[I@1a407d53
        System.out.println(arr[0]);//[I@3498ed 地址值：此时内存元素也创建了
        System.out.println(arr[0][0]);//0

        System.out.println("****************");
        float[][] arr1 = new float[4][3];
        System.out.println(arr1[0]);//地址值
        System.out.println(arr1[0][1]);//0.0

        System.out.println("****************");
        String[][] arr2 = new String[4][2];
        System.out.println(arr2[0]);//[Ljava.lang.String;@79b4d0f
        System.out.println(arr2[0][1]);//null

        System.out.println("****************");
        double[][] arr3 = new double[4][];
        System.out.println(arr3[1]);//null
//        System.out.println(arr3[1][0]);//报错

        //二维数组的元素的长度可以不一样。这被称为不规则数组（ragged array）。  访问二维数组元素时需要格外小心，避免数组越界异常
        int[][] arr4 = new int[4][];
        arr4[1] = new int[]{1, 2, 3};
        arr4[2]=new int[4];
        arr[2][1]=30;
        System.out.println(arr4[1].length);//3
        System.out.println(arr4[2].length);//4

        int[][] arr5 = new int[3][];
        System.out.println(arr5[0]);//null
//        System.out.println(arr5[0][0]);//报错
        arr5[0]=new int[3];
        arr5[0][1] = 5;
        arr5[1]=new int[]{1,2};


        //获取arr数组中所有元素的和  使用for循环嵌套
        int[][] arr6 = new int[][]{{1, 2, 3}, {12, 9}, {7, 0, 6, 4}};
        int sum = 0;//记录总和
        for (int i = 0; i < arr6.length; i++) {
            for (int j = 0; j < arr6[i].length; j++) {
                sum += arr6[i][j];
            }
        }
        System.out.println("数组求和"+sum);//44

        //声明：int[]x,y[] 在给x,y变量赋值之后，以下选项允许通过编译的是
        //提示：
        //一维数组：int[] x 或者 int x[]
        //二维数组：int[][]y 或者 int[] y[] 或者int y[][]
        int[] x, y[];//等价于int x[];   int [][] y;

        /*
        使用二维数组打印一个 10 行杨辉三角。
         * 【提示】
         * 1. 第一行有 1 个元素, 第 n 行有 n 个元素
         * 2. 每一行的第一个元素和最后一个元素都是 1
         * 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。
         * 即：yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
         */
        //1.创建二维数组
        int[][] arr7 = new int[10][];

        //2.给数组元素赋值，遍历二维数组
        for (int i = 0; i < arr7.length; i++) {
            arr7[i] = new int[i + 1];
            //2.1给首尾元素进行赋值1
            arr7[i][0] = arr7[i][i] = 1;
            //2.2给每行非首位元素赋值
           if(i>1){//第一行不需要赋值
               for (int j = 1; j < arr7[i].length-1; j++) {
                   arr7[i][j] = arr7[i - 1][j - 1] + arr7[i - 1][j];
               }
           }
        }

       // arr7.fori 快捷键
       //数组求最大值
       //数组反转
        arrReverse();

    }
// 数组反转
    public static void  arrReverse(){
        System.out.println("-----------------------");
        int[] arr8 = {13, 53, 73, 35, 56};
        for (int i = 0, j=arr8.length-1; i < j; i++,j--) {
            int temp = arr8[j];
            arr8[j] = arr8[i];
            arr8[i] = temp;
        }
        for (int i = 0; i < arr8.length; i++) {
            System.out.print(arr8[i]+" ");
        }

        //随机排名
        //1.定义五名员工
        int[] code = new int[5];
        //2.提示用户录入
        Scanner sc = new Scanner(System.in);

        for (int i = 0; i < code.length; i++) {
            System.out.println("请输入第" + (i + 1) + "名员工工号");
            code[i] = sc.nextInt();
        }

        //3.打乱顺序
        Random r = new Random();
        for (int i = 0; i < code.length; i++) {
            //每遍历到一个数据，都随机uige数组索引范围内的值，然后让当前遍历的数据与该索引位置处的值交换
            int index = r.nextInt(code.length);//0-4
            int temp = code[index];
            code[index] = code[i];
            code[i] = temp;
        }

        for (int i = 0; i < code.length; i++) {
            System.out.print(code[i]+" ");
        }
    }
}
